பைதான் Asyncio வரிசைகள்: ஒரே நேரத்தில் தயாரிப்பாளர்-நுகர்வோர் முறைகளில் தேர்ச்சி பெறுதல்

அதிக செயல்திறன் மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கு ஒத்திசைவற்ற நிரலாக்கம் பெருகிய முறையில் முக்கியத்துவம் வாய்ந்ததாகிவிட்டது. பைத்தானின் asyncio நூலகம் கோரூட்டின்கள் மற்றும் நிகழ்வு சுழல்களைப் பயன்படுத்தி ஒருங்கிசைவை அடைவதற்கான சக்திவாய்ந்த கட்டமைப்பை வழங்குகிறது. asyncio வழங்கும் பல கருவிகளில், ஒரே நேரத்தில் இயங்கும் பணிகளுக்கு இடையேயான தகவல் தொடர்பு மற்றும் தரவு பகிர்வை எளிதாக்குவதில் வரிசைகள் முக்கிய பங்கு வகிக்கின்றன, குறிப்பாக தயாரிப்பாளர்-நுகர்வோர் முறைகளை செயல்படுத்தும் போது.

தயாரிப்பாளர்-நுகர்வோர் முறையைப் புரிந்துகொள்வது

தயாரிப்பாளர்-நுகர்வோர் முறை என்பது ஒரே நேரத்தில் நிரலாக்கத்தில் ஒரு அடிப்படை வடிவமைப்பு முறை ஆகும். இதில் இரண்டு அல்லது அதற்கு மேற்பட்ட வகையான செயல்முறைகள் அல்லது நூல்கள் ஈடுபடுகின்றன: தயாரிப்பாளர்கள், தரவு அல்லது பணிகளை உருவாக்குகிறார்கள், மற்றும் நுகர்வோர், அந்தத் தரவைச் செயலாக்குகிறார்கள் அல்லது பயன்படுத்துகிறார்கள். பகிரப்பட்ட இடையகம், பொதுவாக ஒரு வரிசை, ஒரு இடைத்தரகராக செயல்படுகிறது, இது தயாரிப்பாளர்கள் நுகர்வோரை அதிகமாக நிரப்பாமல் உருப்படிகளைச் சேர்க்கவும், மெதுவான தயாரிப்பாளர்களால் தடுக்கப்படாமல் நுகர்வோர் சுயாதீனமாக வேலை செய்யவும் அனுமதிக்கிறது. இந்த விலகல் ஒருங்கிசைவு, பதிலளிக்கும் திறன் மற்றும் ஒட்டுமொத்த கணினி செயல்திறனை மேம்படுத்துகிறது.

நீங்கள் ஒரு வலை ஸ்கிராப்பரை உருவாக்கும் சூழ்நிலையை கவனியுங்கள். தயாரிப்பாளர்கள் இணையத்திலிருந்து URL களைப் பெறும் பணிகளாகவும், நுகர்வோர் HTML உள்ளடக்கத்தை பாகுபடுத்தி தொடர்புடைய தகவல்களைப் பிரித்தெடுக்கும் பணிகளாகவும் இருக்கலாம். வரிசை இல்லாமல், தயாரிப்பாளர் அடுத்த URL ஐப் பெறுவதற்கு முன்பு நுகர்வோர் செயலாக்கத்தை முடிக்கும் வரை காத்திருக்க வேண்டியிருக்கும், அல்லது அதற்கு நேர்மாறாக. ஒரு வரிசை இந்த பணிகளை ஒரே நேரத்தில் இயக்க உதவுகிறது, இதன் மூலம் செயல்திறனை அதிகரிக்கிறது.

Asyncio வரிசைகளை அறிமுகப்படுத்துதல்

asyncio நூலகம் கோரூட்டின்களுடன் பயன்படுத்துவதற்காக சிறப்பாக வடிவமைக்கப்பட்ட ஒத்திசைவற்ற வரிசை செயலாக்கத்தை (asyncio.Queue) வழங்குகிறது. பாரம்பரிய வரிசைகளைப் போலன்றி, asyncio.Queue உருப்படிகளை வரிசையில் வைப்பதற்கும் வரிசையில் இருந்து பெறுவதற்கும் ஒத்திசைவற்ற செயல்பாடுகளைப் (await) பயன்படுத்துகிறது, இது வரிசை கிடைக்கும் வரை காத்திருக்கும் போது கோரூட்டின்கள் நிகழ்வு சுழலுக்கு கட்டுப்பாட்டை வழங்க அனுமதிக்கிறது. asyncio பயன்பாடுகளில் உண்மையான ஒருங்கிசைவை அடைவதற்கு இந்த தடையற்ற நடத்தை அவசியம்.

Asyncio வரிசைகளின் முக்கிய முறைகள்

asyncio.Queue உடன் வேலை செய்வதற்கான மிக முக்கியமான முறைகள் சில இங்கே:

• put(item): வரிசையில் ஒரு உருப்படியைச் சேர்க்கிறது. வரிசை நிரம்பியிருந்தால் (அதாவது, அதன் அதிகபட்ச அளவை எட்டியிருந்தால்), இடம் கிடைக்கும் வரை கோரூட்டின் தடுக்கும். செயல்பாடு ஒத்திசைவற்ற முறையில் முடிவடைவதை உறுதிசெய்ய await ஐப் பயன்படுத்தவும்: await queue.put(item).
• get(): வரிசையில் இருந்து ஒரு உருப்படியை நீக்கி திருப்பித் தருகிறது. வரிசை காலியாக இருந்தால், ஒரு உருப்படி கிடைக்கும் வரை கோரூட்டின் தடுக்கும். செயல்பாடு ஒத்திசைவற்ற முறையில் முடிவடைவதை உறுதிசெய்ய await ஐப் பயன்படுத்தவும்: await queue.get().
• empty(): வரிசை காலியாக இருந்தால் True ஐத் திருப்பித் தருகிறது; இல்லையெனில், False ஐத் திருப்பித் தருகிறது. ஒருங்கிசைவான சூழலில் இது வெறுமையின் நம்பகமான காட்டி அல்ல என்பதை நினைவில் கொள்க, ஏனெனில் மற்றொரு பணி empty() ஐ அழைப்பதற்கும் அதன் பயன்பாட்டிற்கும் இடையில் ஒரு உருப்படியைச் சேர்க்கலாம் அல்லது நீக்கலாம்.
• full(): வரிசை நிரம்பியிருந்தால் True ஐத் திருப்பித் தருகிறது; இல்லையெனில், False ஐத் திருப்பித் தருகிறது. empty() ஐப் போலவே, இது ஒருங்கிசைவான சூழலில் முழுமையின் நம்பகமான காட்டி அல்ல.
• qsize(): வரிசையில் உள்ள உருப்படிகளின் தோராயமான எண்ணிக்கையைத் திருப்பித் தருகிறது. ஒரே நேரத்தில் செயல்படுவதால் சரியான எண்ணிக்கை சற்று காலாவதியானதாக இருக்கலாம்.
• join(): வரிசையில் உள்ள அனைத்து உருப்படிகளும் பெறப்பட்டு செயலாக்கப்படும் வரை தடுக்கும். நுகர்வோர் அனைத்து உருப்படிகளையும் செயலாக்கி முடித்துவிட்டதாக சமிக்ஞை செய்ய இது பொதுவாகப் பயன்படுத்தப்படுகிறது. பெறப்பட்ட உருப்படியை செயலாக்கிய பிறகு தயாரிப்பாளர்கள் queue.task_done() ஐ அழைக்கிறார்கள்.
• task_done(): முன்பு வரிசையில் சேர்க்கப்பட்ட பணி முடிந்தது என்பதைக் குறிக்கிறது. வரிசை நுகர்வோரால் பயன்படுத்தப்படுகிறது. ஒவ்வொரு get() க்கும், task_done() க்கான அடுத்தடுத்த அழைப்பு வரிசையில் உள்ள பணியின் செயலாக்கம் முடிந்தது என்று கூறுகிறது.

அடிப்படை தயாரிப்பாளர்-நுகர்வோர் உதாரணத்தை செயல்படுத்துதல்

ஒரு எளிய தயாரிப்பாளர்-நுகர்வோர் உதாரணத்துடன் asyncio.Queue பயன்பாட்டை விளக்குவோம். நாங்கள் சீரற்ற எண்களை உருவாக்கும் ஒரு தயாரிப்பாளரையும், அந்த எண்களை சதுரமாக்கும் ஒரு நுகர்வோரையும் உருவகப்படுத்துவோம்.

```python import asyncio import random async def producer(queue: asyncio.Queue, n: int): for _ in range(n): # சில வேலைகளை உருவகப்படுத்துங்கள் await asyncio.sleep(random.random()) value = random.randint(1, 100) print(f"Producer: வரிசையில் {value} ஐச் சேர்க்கிறது") await queue.put(value) # இனி எந்த உருப்படிகளும் சேர்க்கப்படாது என்று நுகர்வோருக்கு சமிக்ஞை செய்யவும் for _ in range(3): # நுகர்வோரின் எண்ணிக்கை await queue.put(None) async def consumer(queue: asyncio.Queue, id: int): while True: value = await queue.get() if value is None: print(f"Consumer {id}: வெளியேறுகிறது.") queue.task_done() break # சில வேலைகளை உருவகப்படுத்துங்கள் await asyncio.sleep(random.random()) result = value * value print(f"Consumer {id}: {value} ஐப் பயன்படுத்தியது, முடிவு: {result}") queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 1 num_consumers = 3 total_items = 10 producers = [asyncio.create_task(producer(queue, total_items // num_producers)) for _ in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, id)) for id in range(num_consumers)] await asyncio.gather(*producers) await queue.join() # அனைத்து உருப்படிகளும் செயலாக்கப்படும் வரை காத்திருக்கவும் await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

இந்த எடுத்துக்காட்டில்:

• producer செயல்பாடு சீரற்ற எண்களை உருவாக்கி வரிசையில் சேர்க்கிறது. அனைத்து எண்களையும் உருவாக்கிய பிறகு, அது முடிந்துவிட்டது என்று நுகர்வோருக்கு சமிக்ஞை செய்ய None ஐ வரிசையில் சேர்க்கிறது.
• consumer செயல்பாடு வரிசையில் இருந்து எண்களை மீட்டெடுத்து, அவற்றை சதுரமாக்கி, முடிவை அச்சிடுகிறது. None சமிக்ஞையைப் பெறும் வரை இது தொடர்கிறது.
• main செயல்பாடு ஒரு asyncio.Queue ஐ உருவாக்கி, தயாரிப்பாளர் மற்றும் நுகர்வோர் பணிகளைத் தொடங்கி, asyncio.gather ஐப் பயன்படுத்தி அவை முடிவடையும் வரை காத்திருக்கிறது.
• முக்கியமானது: ஒரு நுகர்வோர் ஒரு உருப்படியை செயலாக்கிய பிறகு, அது queue.task_done() ஐ அழைக்கிறது. `main()` இல் உள்ள queue.join() அழைப்பு வரிசையில் உள்ள அனைத்து உருப்படிகளும் செயலாக்கப்படும் வரை தடுக்கும் (அதாவது, வரிசையில் வைக்கப்பட்ட ஒவ்வொரு உருப்படிக்கும் `task_done()` அழைக்கப்படும் வரை).
• `asyncio.gather(*consumers)` ஐப் பயன்படுத்தி, `main()` செயல்பாடு வெளியேறும் முன் அனைத்து நுகர்வோரும் முடிவதை உறுதிசெய்கிறோம். `None` ஐப் பயன்படுத்தி நுகர்வோர் வெளியேற சமிக்ஞை செய்யும் போது இது மிகவும் முக்கியமானது.

மேம்பட்ட தயாரிப்பாளர்-நுகர்வோர் முறைகள்

அடிப்படை உதாரணத்தை மேலும் சிக்கலான சூழ்நிலைகளைக் கையாள நீட்டிக்க முடியும். சில மேம்பட்ட முறைகள் இங்கே:

பல தயாரிப்பாளர்கள் மற்றும் நுகர்வோர்

ஒருங்கிசைவை அதிகரிக்க நீங்கள் எளிதாக பல தயாரிப்பாளர்களையும் நுகர்வோரையும் உருவாக்கலாம். வரிசை ஒரு மைய தகவல் தொடர்பு புள்ளியாக செயல்படுகிறது, இது நுகர்வோர் மத்தியில் வேலையை சமமாக விநியோகிக்கிறது.

```python import asyncio import random async def producer(queue: asyncio.Queue, producer_id: int, num_items: int): for i in range(num_items): await asyncio.sleep(random.random() * 0.5) # சில வேலைகளை உருவகப்படுத்துங்கள் item = (producer_id, i) print(f"Producer {producer_id}: உருப்படி {item} ஐ உருவாக்குகிறது") await queue.put(item) print(f"Producer {producer_id}: உருவாக்குவதை முடித்தது.") # இங்கே நுகர்வோருக்கு சமிக்ஞை செய்ய வேண்டாம்; அதை பிரதானமாக கையாளவும் async def consumer(queue: asyncio.Queue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: வெளியேறுகிறது.") queue.task_done() break producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # செயலாக்க நேரத்தை உருவகப்படுத்துங்கள் print(f"Consumer {consumer_id}: Producer {producer_id} இலிருந்து உருப்படி {item} ஐப் பயன்படுத்துகிறது") queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 3 num_consumers = 5 items_per_producer = 10 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # அனைத்து தயாரிப்பாளர்களும் முடித்த பிறகு நுகர்வோருக்கு வெளியேற சமிக்ஞை செய்யவும். for _ in range(num_consumers): await queue.put(None) await queue.join() await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

இந்த மாற்றியமைக்கப்பட்ட எடுத்துக்காட்டில், எங்களிடம் பல தயாரிப்பாளர்கள் மற்றும் பல நுகர்வோர் உள்ளனர். ஒவ்வொரு தயாரிப்பாளருக்கும் ஒரு தனிப்பட்ட ID ஒதுக்கப்படுகிறது, மேலும் ஒவ்வொரு நுகர்வோரும் வரிசையில் இருந்து உருப்படிகளை மீட்டெடுத்து அவற்றைப் செயலாக்குகிறார்கள். அனைத்து தயாரிப்பாளர்களும் முடித்ததும், நுகர்வோருக்கு இனி வேலை இருக்காது என்று சமிக்ஞை செய்ய None சென்டினல் மதிப்பு வரிசையில் சேர்க்கப்படுகிறது. முக்கியமாக, வெளியேறுவதற்கு முன் queue.join() ஐ அழைக்கிறோம். ஒரு உருப்படியை செயலாக்கிய பிறகு நுகர்வோர் queue.task_done() ஐ அழைக்கிறார்.

விதிவிலக்குகளை கையாளுதல்

உண்மையான பயன்பாடுகளில், தயாரிப்பு அல்லது நுகர்வு செயல்பாட்டின் போது ஏற்படக்கூடிய விதிவிலக்குகளை நீங்கள் கையாள வேண்டும். விதிவிலக்குகளை கவனித்து கையாளுவதற்கு உங்கள் தயாரிப்பாளர் மற்றும் நுகர்வோர் கோரூட்டின்களில் try...except தொகுதிகளைப் பயன்படுத்தலாம்.

```python import asyncio import random async def producer(queue: asyncio.Queue, producer_id: int, num_items: int): for i in range(num_items): try: await asyncio.sleep(random.random() * 0.5) # சில வேலைகளை உருவகப்படுத்துங்கள் if random.random() < 0.1: # பிழையை உருவகப்படுத்துங்கள் raise Exception(f"Producer {producer_id}: உருவகப்படுத்தப்பட்ட பிழை!") item = (producer_id, i) print(f"Producer {producer_id}: உருப்படி {item} ஐ உருவாக்குகிறது") await queue.put(item) except Exception as e: print(f"Producer {producer_id}: உருப்படியை உருவாக்குவதில் பிழை: {e}") # விருப்பமாக, வரிசையில் ஒரு சிறப்பு பிழை உருப்படியை வைக்கவும் # await queue.put(('ERROR', str(e))) print(f"Producer {producer_id}: உருவாக்குவதை முடித்தது.") async def consumer(queue: asyncio.Queue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: வெளியேறுகிறது.") queue.task_done() break try: producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # செயலாக்க நேரத்தை உருவகப்படுத்துங்கள் if random.random() < 0.05: # நுகர்வு போது பிழையை உருவகப்படுத்துங்கள் raise ValueError(f"Consumer {consumer_id}: தவறான உருப்படி!") print(f"Consumer {consumer_id}: Producer {producer_id} இலிருந்து உருப்படி {item} ஐப் பயன்படுத்துகிறது") except Exception as e: print(f"Consumer {consumer_id}: உருப்படியைப் பயன்படுத்துவதில் பிழை: {e}") finally: queue.task_done() async def main(): queue = asyncio.Queue() num_producers = 3 num_consumers = 5 items_per_producer = 10 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # அனைத்து தயாரிப்பாளர்களும் முடித்த பிறகு நுகர்வோருக்கு வெளியேற சமிக்ஞை செய்யவும். for _ in range(num_consumers): await queue.put(None) await queue.join() await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

இந்த எடுத்துக்காட்டில், தயாரிப்பாளர் மற்றும் நுகர்வோர் இரண்டிலும் உருவகப்படுத்தப்பட்ட பிழைகளை அறிமுகப்படுத்துகிறோம். try...except தொகுதிகள் இந்த பிழைகளைப் பிடிக்கின்றன, இதன் மூலம் பணிகள் மற்ற உருப்படிகளைத் தொடர்ந்து செயலாக்க அனுமதிக்கின்றன. நுகர்வோர் இன்னும் `queue.task_done()` ஐ `finally` தொகுதியில் அழைக்கிறார், இதனால் விதிவிலக்குகள் ஏற்பட்டாலும் வரிசையின் உள் கவுண்டர் சரியாக புதுப்பிக்கப்படுவதை உறுதி செய்கிறது.

முன்னுரிமை பணிகள்

சில நேரங்களில், நீங்கள் மற்ற பணிகளை விட சில பணிகளுக்கு முன்னுரிமை அளிக்க வேண்டியிருக்கும். asyncio நேரடியாக முன்னுரிமை வரிசையை வழங்காது, ஆனால் heapq தொகுதியைப் பயன்படுத்தி ஒன்றை எளிதாக செயல்படுத்தலாம்.

```python import asyncio import heapq import random class PriorityQueue: def __init__(self): self._queue = [] self._count = 0 self._condition = asyncio.Condition(asyncio.Lock()) async def put(self, item, priority): async with self._condition: heapq.heappush(self._queue, (priority, self._count, item)) self._count += 1 self._condition.notify_all() async def get(self): async with self._condition: while not self._queue: await self._condition.wait() priority, count, item = heapq.heappop(self._queue) return item def qsize(self): return len(self._queue) def empty(self): return not self._queue async def producer(queue: PriorityQueue, producer_id: int, num_items: int): for i in range(num_items): await asyncio.sleep(random.random() * 0.5) # சில வேலைகளை உருவகப்படுத்துங்கள் priority = random.randint(1, 10) # சீரற்ற முன்னுரிமையை ஒதுக்கவும் item = (producer_id, i) print(f"Producer {producer_id}: முன்னுரிமை {priority} உடன் உருப்படி {item} ஐ உருவாக்குகிறது") await queue.put(item, priority) print(f"Producer {producer_id}: உருவாக்குவதை முடித்தது.") async def consumer(queue: PriorityQueue, consumer_id: int): while True: item = await queue.get() if item is None: print(f"Consumer {consumer_id}: வெளியேறுகிறது.") break producer_id, item_id = item await asyncio.sleep(random.random() * 0.5) # செயலாக்க நேரத்தை உருவகப்படுத்துங்கள் print(f"Consumer {consumer_id}: Producer {producer_id} இலிருந்து உருப்படி {item} ஐப் பயன்படுத்துகிறது") async def main(): queue = PriorityQueue() num_producers = 2 num_consumers = 3 items_per_producer = 5 producers = [asyncio.create_task(producer(queue, i, items_per_producer)) for i in range(num_producers)] consumers = [asyncio.create_task(consumer(queue, i)) for i in range(num_consumers)] await asyncio.gather(*producers) # நுகர்வோருக்கு வெளியேற சமிக்ஞை செய்யவும் (இந்த எடுத்துக்காட்டிற்கு தேவையில்லை). # for _ in range(num_consumers): # await queue.put(None, 0) await asyncio.gather(*consumers) if __name__ == "__main__": asyncio.run(main()) ```

இந்த எடுத்துக்காட்டு heapq ஐப் பயன்படுத்தி முன்னுரிமையின் அடிப்படையில் வரிசைப்படுத்தப்பட்ட வரிசையை பராமரிக்கிறது. குறைந்த முன்னுரிமை மதிப்புகளைக் கொண்ட உருப்படிகள் முதலில் செயலாக்கப்படும். இந்த முன்னுரிமை வரிசை எடுத்துக்காட்டில் டாஸ்க் முடிவை கண்காணிக்க உள்ளமைக்கப்பட்ட வழி இல்லாததால், நாங்கள் `queue.join()` மற்றும் `queue.task_done()` ஐப் பயன்படுத்துவதில்லை என்பதை கவனியுங்கள், நுகர்வோர் தானாக வெளியேற மாட்டார்கள், எனவே அவர்கள் நிறுத்தப்பட வேண்டியிருந்தால், நுகர்வோர் வெளியேற சமிக்ஞை செய்யும் வழி செயல்படுத்தப்பட வேண்டும். queue.join() மற்றும் queue.task_done() முக்கியமாக இருந்தால், ஒருவருக்கு இதே போன்ற செயல்பாட்டை ஆதரிக்க தனிப்பயன் முன்னுரிமை வரிசை வகுப்பை நீட்டிக்க அல்லது மாற்றியமைக்க வேண்டியிருக்கும்.

காலக்கெடு மற்றும் ரத்து

சில சந்தர்ப்பங்களில், வரிசையில் உருப்படிகளைப் பெறுவதற்கு அல்லது வைப்பதற்கு காலக்கெடுவை அமைக்க விரும்பலாம். இதை அடைய asyncio.wait_for ஐப் பயன்படுத்தலாம்.

```python import asyncio async def consumer(queue: asyncio.Queue): while True: try: item = await asyncio.wait_for(queue.get(), timeout=5.0) # 5 வினாடிகள் கழித்து காலக்கெடு print(f"Consumer: {item} ஐப் பயன்படுத்தியது") queue.task_done() except asyncio.TimeoutError: print("Consumer: உருப்படிக்காக காத்திருப்பதில் காலக்கெடு") break except asyncio.CancelledError: print("Consumer: ரத்து செய்யப்பட்டது") break async def main(): queue = asyncio.Queue() consumer_task = asyncio.create_task(consumer(queue)) await asyncio.sleep(10) # நுகர்வோருக்கு சிறிது நேரம் கொடுங்கள் print("Producer: நுகர்வோரை ரத்து செய்கிறது") consumer_task.cancel() try: await consumer_task # விதிவிலக்குகளைக் கையாள ரத்து செய்யப்பட்ட பணியை எதிர்பார்க்கவும் except asyncio.CancelledError: print("Main: நுகர்வோர் பணி வெற்றிகரமாக ரத்து செய்யப்பட்டது.") if __name__ == "__main__": asyncio.run(main()) ```

இந்த எடுத்துக்காட்டில், நுகர்வோர் வரிசையில் ஒரு உருப்படி கிடைக்கும் வரை அதிகபட்சம் 5 வினாடிகள் காத்திருப்பார். காலக்கெடுவிற்குள் எந்த உருப்படியும் கிடைக்கவில்லை என்றால், அது asyncio.TimeoutError ஐ உயர்த்தும். task.cancel() ஐப் பயன்படுத்தி நுகர்வோர் பணியையும் ரத்து செய்யலாம்.

சிறந்த நடைமுறைகள் மற்றும் பரிசீலனைகள்

• வரிசை அளவு: எதிர்பார்க்கப்படும் பணிச்சுமை மற்றும் கிடைக்கக்கூடிய நினைவகத்தின் அடிப்படையில் பொருத்தமான வரிசை அளவைத் தேர்வு செய்யவும். சிறிய வரிசை தயாரிப்பாளர்கள் அடிக்கடி தடுப்பதற்கு வழிவகுக்கும், அதே நேரத்தில் பெரிய வரிசை அதிகப்படியான நினைவகத்தைப் பயன்படுத்தலாம். உங்கள் பயன்பாட்டிற்கான உகந்த அளவைக் கண்டறிய சோதனையிடவும். வரம்பற்ற வரிசையை உருவாக்குவது ஒரு பொதுவான தவறான முறை.
• பிழை கையாளுதல்: விதிவிலக்குகள் உங்கள் பயன்பாட்டை செயலிழக்கச் செய்வதைத் தடுக்க வலுவான பிழை கையாளுதலை செயல்படுத்தவும். தயாரிப்பாளர் மற்றும் நுகர்வோர் பணிகள் இரண்டிலும் விதிவிலக்குகளைப் பிடிக்கவும் கையாளவும் try...except தொகுதிகளைப் பயன்படுத்தவும்.
• முட்டுக்கட்டை தடுப்பு: பல வரிசைகள் அல்லது பிற ஒத்திசைவு பழக்கவழக்கங்களைப் பயன்படுத்தும் போது முட்டுக்கட்டைகளைத் தவிர்க்க கவனமாக இருங்கள். சுழற்சி சார்புகளைத் தடுக்க, பணிகள் நிலையான வரிசையில் ஆதாரங்களை வெளியிடுவதை உறுதிசெய்யவும். தேவையான போது `queue.join()` மற்றும் `queue.task_done()` ஐப் பயன்படுத்தி பணி முடிவை கையாளுவதை உறுதிசெய்யவும்.
• முடிவு சமிக்ஞை: ஒரு சென்டினல் மதிப்பு (எ.கா., None) அல்லது பகிரப்பட்ட கொடி போன்ற நுகர்வோருக்கு முடிவை சமிக்ஞை செய்ய நம்பகமான பொறிமுறையைப் பயன்படுத்தவும். அனைத்து நுகர்வோரும் இறுதியில் சமிக்ஞையைப் பெற்று கருணையுடன் வெளியேறுவதை உறுதிசெய்யவும். சுத்தமான பயன்பாட்டு நிறுத்தத்திற்கு நுகர்வோர் வெளியேறுவதை சரியாக சமிக்ஞை செய்யவும்.
• சூழல் மேலாண்மை: கோப்புகள் அல்லது தரவுத்தள இணைப்புகள் போன்ற ஆதாரங்களுக்கான `async with` அறிக்கைகளைப் பயன்படுத்தி asyncio டாஸ்க் சூழல்களைச் சரியாக நிர்வகிக்கவும், இதனால் பிழைகள் ஏற்பட்டாலும் சரியான சுத்தம் உத்தரவாதம் அளிக்கப்படுகிறது.
• கண்காணிப்பு: சாத்தியமான தடைகளை அடையாளம் கண்டு செயல்திறனை மேம்படுத்த வரிசை அளவு, தயாரிப்பாளர் செயல்திறன் மற்றும் நுகர்வோர் தாமதத்தை கண்காணிக்கவும். சிக்கல்களை பிழைதிருத்தம் செய்ய பதிவுகள் பயனுள்ளதாக இருக்கும்.
• தடுக்கும் செயல்பாடுகளைத் தவிர்க்கவும்: உங்கள் கோரூட்டின்களுக்குள் நேரடியாக தடுக்கும் செயல்பாடுகளை (எ.கா., ஒத்திசைவான I/O, நீண்டகால கணக்கீடுகள்) செய்ய வேண்டாம். தடுக்கும் செயல்பாடுகளை ஒரு தனி நூலுக்கு அல்லது செயலாக்கத் தொகுப்பிற்கு மாற்ற asyncio.to_thread() அல்லது செயலாக்கத் தொகுப்பைப் பயன்படுத்தவும்.

உண்மையான உலக பயன்பாடுகள்

asyncio வரிசைகளுடன் கூடிய தயாரிப்பாளர்-நுகர்வோர் முறை பல்வேறு உண்மையான உலக சூழ்நிலைகளுக்கு பொருந்தும்:

• வலை ஸ்கிராப்பர்கள்: தயாரிப்பாளர்கள் வலைப்பக்கங்களைப் பெறுகிறார்கள், மற்றும் நுகர்வோர் தரவைப் பாகுபடுத்தி பிரித்தெடுக்கிறார்கள்.
• பட/வீடியோ செயலாக்கம்: தயாரிப்பாளர்கள் வட்டு அல்லது நெட்வொர்க்கிலிருந்து படங்கள்/வீடியோக்களைப் படிக்கிறார்கள், மற்றும் நுகர்வோர் செயலாக்க செயல்பாடுகளைச் செய்கிறார்கள் (எ.கா., மறுஅளவிடுதல், வடிகட்டுதல்).
• தரவு குழாய்கள்: தயாரிப்பாளர்கள் பல்வேறு மூலங்களிலிருந்து தரவைச் சேகரிக்கிறார்கள் (எ.கா., சென்சார்கள், API கள்), மற்றும் நுகர்வோர் தரவை மாற்றி தரவுத்தளம் அல்லது தரவு கிடங்கில் ஏற்றுகிறார்கள்.
• செய்தி வரிசைகள்: asyncio வரிசைகளை தனிப்பயன் செய்தி வரிசை அமைப்புகளை செயல்படுத்த ஒரு கட்டுமானத் தொகுதியாகப் பயன்படுத்தலாம்.
• வலை பயன்பாடுகளில் பின்னணி பணி செயலாக்கம்: தயாரிப்பாளர்கள் HTTP கோரிக்கைகளைப் பெற்று பின்னணி பணிகளை வரிசைப்படுத்துகிறார்கள், மற்றும் நுகர்வோர் அந்த பணிகளை ஒத்திசைவற்ற முறையில் செயலாக்குகிறார்கள். மின்னஞ்சல்களை அனுப்புவது அல்லது தரவைப் செயலாக்குவது போன்ற நீண்டகால செயல்பாடுகளில் பிரதான வலை பயன்பாடு தடுப்பதைத் இது தடுக்கிறது.
• நிதி வர்த்தக அமைப்புகள்: தயாரிப்பாளர்கள் சந்தை தரவு ஊட்டங்களைப் பெறுகிறார்கள், மற்றும் நுகர்வோர் தரவை பகுப்பாய்வு செய்து வர்த்தகங்களைச் செய்கிறார்கள். asyncio இன் ஒத்திசைவற்ற தன்மை கிட்டத்தட்ட நிகழ்நேர பதில் நேரங்களுக்கும் அதிக அளவிலான தரவைக் கையாளுவதற்கும் அனுமதிக்கிறது.
• IoT தரவு செயலாக்கம்: தயாரிப்பாளர்கள் IoT சாதனங்களிலிருந்து தரவைச் சேகரிக்கிறார்கள், மற்றும் நுகர்வோர் தரவை நிகழ்நேரத்தில் செயலாக்கி பகுப்பாய்வு செய்கிறார்கள். Asyncio பல்வேறு சாதனங்களிலிருந்து வரும் அதிக எண்ணிக்கையிலான ஒரே நேரத்தில் இணைப்புகளைக் கையாள கணினியை இயக்குகிறது, இது IoT பயன்பாடுகளுக்கு ஏற்றதாக அமைகிறது.

Asyncio வரிசைகளுக்கு மாற்றுகள்

asyncio.Queue ஒரு சக்திவாய்ந்த கருவியாக இருந்தாலும், இது ஒவ்வொரு சூழ்நிலையிலும் சிறந்த தேர்வாக இருக்காது. கருத்தில் கொள்ள வேண்டிய சில மாற்றுகள் இங்கே:

• மல்டிபுரோசஸ்ஸிங் வரிசைகள்: நீங்கள் நூல்களைப் பயன்படுத்தி திறமையாக இணையானமயமாக்க முடியாத CPU-கட்டுப்படுத்தப்பட்ட செயல்பாடுகளைச் செய்ய வேண்டியிருந்தால் (குளோபல் இன்டர்ப்ரீட்டர் லாக் - GIL காரணமாக), multiprocessing.Queue ஐப் பயன்படுத்தவும். இது GIL ஐ கடந்து, தயாரிப்பாளர்களையும் நுகர்வோரையும் தனி செயல்முறைகளில் இயக்க அனுமதிக்கிறது. இருப்பினும், செயல்முறைகளுக்கு இடையேயான தகவல் தொடர்பு பொதுவாக நூல்களுக்கு இடையேயான தகவல்தொடர்புகளை விட அதிக விலை உயர்ந்தது என்பதை நினைவில் கொள்க.
• மூன்றாம் தரப்பு செய்தி வரிசைகள் (எ.கா., RabbitMQ, Kafka): மேலும் சிக்கலான மற்றும் விநியோகிக்கப்பட்ட பயன்பாடுகளுக்கு, RabbitMQ அல்லது Kafka போன்ற பிரத்யேக செய்தி வரிசை அமைப்பைப் பயன்படுத்துவதைக் கவனியுங்கள். இந்த அமைப்புகள் செய்தி ரூட்டிங், தொடர்ச்சி மற்றும் அளவிடுதல் போன்ற மேம்பட்ட அம்சங்களை வழங்குகின்றன.
• சேனல்கள் (எ.கா., Trio): வரிசைகளுடன் ஒப்பிடும்போது ஒரே நேரத்தில் பணிகளுக்கு இடையே தொடர்புகொள்வதற்கு அதிக கட்டமைக்கப்பட்ட மற்றும் ஒருங்கிணைக்கக்கூடிய வழியை Trio நூலகம் சேனல்களை வழங்குகிறது.
• aiormq (asyncio RabbitMQ கிளையன்ட்): RabbitMQ க்கு உங்களுக்கு குறிப்பாக ஒத்திசைவற்ற இடைமுகம் தேவைப்பட்டால், aiormq நூலகம் ஒரு சிறந்த தேர்வாகும்.

முடிவு

asyncio வரிசைகள் பைத்தானில் ஒரே நேரத்தில் தயாரிப்பாளர்-நுகர்வோர் முறைகளைச் செயல்படுத்துவதற்கான வலுவான மற்றும் திறமையான பொறிமுறையை வழங்குகின்றன. இந்த வழிகாட்டியில் விவாதிக்கப்பட்ட முக்கிய கருத்துகள் மற்றும் சிறந்த நடைமுறைகளைப் புரிந்துகொள்வதன் மூலம், உயர் செயல்திறன், அளவிடக்கூடிய மற்றும் பதிலளிக்கக்கூடிய பயன்பாடுகளை உருவாக்க asyncio வரிசைகளை நீங்கள் பயன்படுத்தலாம். உங்கள் குறிப்பிட்ட தேவைகளுக்கு உகந்த தீர்வை கண்டுபிடிக்க வெவ்வேறு வரிசை அளவுகள், பிழை கையாளுதல் உத்திகள் மற்றும் மேம்பட்ட முறைகளை பரிசோதிக்கவும். asyncio மற்றும் வரிசைகளுடன் ஒத்திசைவற்ற நிரலாக்கத்தை ஏற்றுக்கொள்வது, தேவைப்படும் பணிச்சுமைகளைக் கையாளக்கூடிய மற்றும் விதிவிலக்கான பயனர் அனுபவங்களை வழங்கக்கூடிய பயன்பாடுகளை உருவாக்க உங்களுக்கு அதிகாரம் அளிக்கிறது.